Eloquent JavaScript: A Modern Introduction to Programming: The Grammar of Strings: Defining Patterns with RegExp

Regular Expressions (RegExp) are a specialized formal grammar used to describe, match, and manipulate patterns within string data. In JavaScript, a RegExp acts as a blueprint for the engine to perform search-and-validate operations.

1. Defining the Grammar

There are two primary ways to instantiate a pattern: the literal notation (var re2 = /abc/;), compiled when the script loads, and the RegExp constructor (var re1 = new RegExp("abc");), which allows for building patterns dynamically from variables.

2. The .test() Method

The .test() method is the most fundamental way to apply this grammar; it returns a Boolean indicating if the pattern exists anywhere within the target string. Certain characters like + have functional meanings and must be escaped with a backslash (e.g., /eighteen\+/) to be matched literally.

TERMINAL bash — 80x24

> Ready. Click "Run" to execute.

QUESTION 1

Which notation is compiled when the script is first loaded?

The RegExp constructor notation.

The literal value notation (e.g., /abc/).

The string.match() method.

The JSON.parse() notation.

QUESTION 2

What is the return type of the RegExp .test() method?

String

Number

Boolean

Object

QUESTION 3

How do you match a literal plus sign (+) in a regular expression?

By using double quotes.

By escaping it with a backslash: \+.

By placing it in parentheses.

Plus signs are always matched literally by default.

QUESTION 4

Which flag is used to perform a case-insensitive search?

The 'g' flag.

The 's' flag.

The 'i' flag.

The 'c' flag.

QUESTION 5

When would you prefer the RegExp constructor over literal notation?

When the pattern is constant throughout the program.

When you need to build a pattern from a variable string.

When you want better performance.

Literal notation is always preferred.

Case Study: Product Code Validation

Applying RegExp to Database Filtering

A logistics company uses product codes that start with the prefix 'abc'. However, legacy systems sometimes enter these in uppercase ('ABC') or mixed case ('aBc'). You need to create a validator that identifies these codes regardless of case.

1. Write the literal regular expression to match 'abc' case-insensitively.

Solution:
The pattern is /abc/i. The 'i' flag ensures that 'ABC', 'abc', and 'AbC' all return true when tested.

2. If you were receiving the prefix as a user-provided string variable named 'prefix', how would you initialize the RegExp?

Solution:
You would use the constructor: new RegExp(prefix, "i"). This allows the pattern to be dynamic while still applying the case-insensitive flag.

3. Why does /abc/.test("abcde") return true even though the strings aren't identical?

Solution:
By default, a regular expression looks for the pattern anywhere within the string, not just an exact full-string match. Since 'abc' exists at the start of 'abcde', the test passes.